{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Using Tensorflow through ONNX:\n",
    "\n",
    "The ONNX path to getting a TensorRT engine is a high-performance approach to TensorRT conversion that works with a variety of frameworks - including Tensorflow and Tensorflow 2.\n",
    "\n",
    "TensorRT's ONNX parser is an all-or-nothing parser for ONNX models that ensures an optimal, single TensorRT engine and is great for exporting to the TensorRT API runtimes. ONNX models can be easily generated from Tensorflow models using the ONNX project's keras2onnx and tf2onnx tools.\n",
    "\n",
    "In this notebook we will take a look at how ONNX models can be generated from a Keras/TF2 ResNet50 model, how we can convert those ONNX models to TensorRT engines using trtexec, and finally how we can use the native Python TensorRT runtime to feed a batch of data into the TRT engine at inference time.\n",
    "\n",
    "Essentially, we will follow this path to convert and deploy our model:\n",
    "\n",
    "![Tensorflow+ONNX](./images/tf_onnx.png)\n",
    "\n",
    "__Use this when:__\n",
    "- You want the most efficient runtime performance possible out of an automatic parser\n",
    "- You have a network consisting of mostly supported operations -  including operations and layers that the ONNX parser uniquely supports (Such as RNNs/LSTMs/GRUs)\n",
    "- You are willing to write custom C++ plugins for any unsupported operations (if your network has any)\n",
    "- You do not want to use the manual layer builder API"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Checking your GPU status:__\n",
    "\n",
    "Lets see what GPU hardware we are working with. Our hardware can matter a lot because different cards have different performance profiles and precisions they tend to operate best in. For example, a V100 is relatively strong as FP16 processing vs a T4, which tends to operate best in the INT8 mode."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 377
    },
    "id": "IJBfZsGo8yaV",
    "outputId": "f4c4e20d-fcfd-43a2-b10d-c6978c25c91f"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wed Jun  9 19:47:48 2021       \n",
      "+-----------------------------------------------------------------------------+\n",
      "| NVIDIA-SMI 450.80.02    Driver Version: 450.80.02    CUDA Version: 11.3     |\n",
      "|-------------------------------+----------------------+----------------------+\n",
      "| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |\n",
      "| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |\n",
      "|                               |                      |               MIG M. |\n",
      "|===============================+======================+======================|\n",
      "|   0  Tesla V100-DGXS...  On   | 00000000:07:00.0 Off |                    0 |\n",
      "| N/A   45C    P0    63W / 300W |   5572MiB / 16155MiB |      0%      Default |\n",
      "|                               |                      |                  N/A |\n",
      "+-------------------------------+----------------------+----------------------+\n",
      "|   1  Tesla V100-DGXS...  On   | 00000000:08:00.0 Off |                    0 |\n",
      "| N/A   44C    P0    41W / 300W |      9MiB / 16158MiB |      0%      Default |\n",
      "|                               |                      |                  N/A |\n",
      "+-------------------------------+----------------------+----------------------+\n",
      "|   2  Tesla V100-DGXS...  On   | 00000000:0E:00.0 Off |                    0 |\n",
      "| N/A   43C    P0    41W / 300W |      9MiB / 16158MiB |      0%      Default |\n",
      "|                               |                      |                  N/A |\n",
      "+-------------------------------+----------------------+----------------------+\n",
      "|   3  Tesla V100-DGXS...  On   | 00000000:0F:00.0 Off |                    0 |\n",
      "| N/A   44C    P0    39W / 300W |      9MiB / 16158MiB |      0%      Default |\n",
      "|                               |                      |                  N/A |\n",
      "+-------------------------------+----------------------+----------------------+\n",
      "                                                                               \n",
      "+-----------------------------------------------------------------------------+\n",
      "| Processes:                                                                  |\n",
      "|  GPU   GI   CI        PID   Type   Process name                  GPU Memory |\n",
      "|        ID   ID                                                   Usage      |\n",
      "|=============================================================================|\n",
      "+-----------------------------------------------------------------------------+\n"
     ]
    }
   ],
   "source": [
    "!nvidia-smi"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Remember to sucessfully deploy a TensorRT model, you have to make __five key decisions__:\n",
    "\n",
    "1. __What format should I save my model in?__\n",
    "2. __What batch size(s) am I running inference at?__\n",
    "3. __What precision am I running inference at?__\n",
    "4. __What TensorRT path am I using to convert my model?__\n",
    "5. __What runtime am I targeting?__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. What format should I save my model in?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Our first step is to load up a pretrained ResNet50 model. This can be done easily using keras.applications - a collection of pretrained image model classifiers that can additionally be used as backbones for detection and other deep learning problems.\n",
    "\n",
    "We can load up a pretrained classifier with batch size 32 as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "id": "iVRVItvR8quS"
   },
   "outputs": [],
   "source": [
    "from tensorflow.keras.applications import ResNet50\n",
    "\n",
    "BATCH_SIZE = 32"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "id": "cKT07xPV8qua"
   },
   "outputs": [],
   "source": [
    "model = ResNet50(weights='imagenet')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For the purposes of checking our non-optimized model, we can use a dummy batch of data to verify our performance and the consistency of our results across precisions. 224x224 RGB images are a common  format, so lets generate a batch of them.\n",
    "\n",
    "Once we generate a batch of them, we will feed it through the model using .predict() to \"warm up\" the model. The first batch you feed through a deep learning model often takes a lot longer as just-in-time compilation and other runtime optimizations are performed. Once you get that first batch through, further performance tends to be more consistent.\n",
    "\n",
    "To create a test batch, we will simply repeat one open-source dog image from http://www.dog.ceo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(32, 224, 224, 3)"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "from skimage import io\n",
    "from skimage.transform import resize\n",
    "from matplotlib import pyplot as plt\n",
    "\n",
    "url='https://images.dog.ceo/breeds/retriever-golden/n02099601_3004.jpg'\n",
    "img = resize(io.imread(url), (224, 224))\n",
    "input_batch = 255*np.array(np.repeat(np.expand_dims(np.array(img, dtype=np.float32), axis=0), BATCH_SIZE, axis=0), dtype=np.float32)\n",
    "\n",
    "input_batch.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7fd3a009bf70>"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.imshow(input_batch[0]/255)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The image above is a Golden Retriever, class 207 in ImageNet. So we look for class 207  in the top 5 predictions to verify our model works as intended:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Class | Probability (out of 1)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[(160, 0.32290387),\n",
       " (169, 0.266499),\n",
       " (212, 0.16812354),\n",
       " (170, 0.07066823),\n",
       " (207, 0.03341851)]"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "predictions = model.predict(input_batch) # warm up\n",
    "indices = (-predictions[0]).argsort()[:5]\n",
    "print(\"Class | Probability (out of 1)\")\n",
    "list(zip(indices, predictions[0][indices]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Labels 150 to 275 or so are dogs in ImageNet, so look for those as other common predictions in addition to our correct 207 class."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Baseline Timing:__\n",
    "\n",
    "Once we have warmed up our non-optimized model, we can get a rough timing estimate of our model using %%timeit, which runs the cell several times and reports timing information.\n",
    "\n",
    "Lets take a look at how long our model takes to run at baseline before doing any TensorRT optimization:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 85
    },
    "id": "eMu3dZlM96bh",
    "outputId": "537a88e2-ad7d-413a-f815-abd91f010e21"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "46.8 ms ± 514 µs per loop (mean ± std. dev. of 7 runs, 1 loop each)\n"
     ]
    }
   ],
   "source": [
    "%%timeit\n",
    "\n",
    "result = model.predict_on_batch(input_batch) # Check default performance"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Okay - now that we have a baseline model, lets convert it to the format TensorRT understands best: ONNX. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Convert Keras model to ONNX intermediate model and save:__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The ONNX format is a framework-agnostic way of describing and saving the structure and state of deep learning models. We can convert Tensorflow 2 Keras models to ONNX using the keras2onnx tool provided by the ONNX project. (You can find the ONNX project here: https://onnx.ai or on GitHub here: https://github.com/onnx/onnx)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "id": "aG3tXUEx8quf"
   },
   "outputs": [],
   "source": [
    "import onnx, keras2onnx"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Converting a model with default parameters to an ONNX model is fairly straightforward:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 68
    },
    "id": "QxLAvWp68quk",
    "outputId": "d750962a-d098-4a63-c195-c3442211cdc1"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: my_model/assets\n",
      "2021-06-09 19:48:30.462380: I tensorflow/stream_executor/platform/default/dso_loader.cc:49] Successfully opened dynamic library libcudart.so.11.0\n",
      "/usr/lib/python3.8/runpy.py:127: RuntimeWarning: 'tf2onnx.convert' found in sys.modules after import of package 'tf2onnx', but prior to execution of 'tf2onnx.convert'; this may result in unpredictable behaviour\n",
      "  warn(RuntimeWarning(msg))\n",
      "2021-06-09 19:48:31.938818: I tensorflow/compiler/jit/xla_cpu_device.cc:41] Not creating XLA devices, tf_xla_enable_xla_devices not set\n",
      "2021-06-09 19:48:31.939684: I tensorflow/stream_executor/platform/default/dso_loader.cc:49] Successfully opened dynamic library libcuda.so.1\n",
      "2021-06-09 19:48:32.010614: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1747] Found device 0 with properties: \n",
      "pciBusID: 0000:07:00.0 name: Tesla V100-DGXS-16GB computeCapability: 7.0\n",
      "coreClock: 1.53GHz coreCount: 80 deviceMemorySize: 15.78GiB deviceMemoryBandwidth: 836.37GiB/s\n",
      "2021-06-09 19:48:32.011850: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1747] Found device 1 with properties: \n",
      "pciBusID: 0000:08:00.0 name: Tesla V100-DGXS-16GB computeCapability: 7.0\n",
      "coreClock: 1.53GHz coreCount: 80 deviceMemorySize: 15.78GiB deviceMemoryBandwidth: 836.37GiB/s\n",
      "2021-06-09 19:48:32.013128: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1747] Found device 2 with properties: \n",
      "pciBusID: 0000:0e:00.0 name: Tesla V100-DGXS-16GB computeCapability: 7.0\n",
      "coreClock: 1.53GHz coreCount: 80 deviceMemorySize: 15.78GiB deviceMemoryBandwidth: 836.37GiB/s\n",
      "2021-06-09 19:48:32.014344: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1747] Found device 3 with properties: \n",
      "pciBusID: 0000:0f:00.0 name: Tesla V100-DGXS-16GB computeCapability: 7.0\n",
      "coreClock: 1.53GHz coreCount: 80 deviceMemorySize: 15.78GiB deviceMemoryBandwidth: 836.37GiB/s\n",
      "2021-06-09 19:48:32.014373: I tensorflow/stream_executor/platform/default/dso_loader.cc:49] Successfully opened dynamic library libcudart.so.11.0\n",
      "2021-06-09 19:48:32.019097: I tensorflow/stream_executor/platform/default/dso_loader.cc:49] Successfully opened dynamic library libcublas.so.11\n",
      "2021-06-09 19:48:32.019146: I tensorflow/stream_executor/platform/default/dso_loader.cc:49] Successfully opened dynamic library libcublasLt.so.11\n",
      "2021-06-09 19:48:32.020281: I tensorflow/stream_executor/platform/default/dso_loader.cc:49] Successfully opened dynamic library libcufft.so.10\n",
      "2021-06-09 19:48:32.020567: I tensorflow/stream_executor/platform/default/dso_loader.cc:49] Successfully opened dynamic library libcurand.so.10\n",
      "2021-06-09 19:48:32.021254: I tensorflow/stream_executor/platform/default/dso_loader.cc:49] Successfully opened dynamic library libcusolver.so.11\n",
      "2021-06-09 19:48:32.022280: I tensorflow/stream_executor/platform/default/dso_loader.cc:49] Successfully opened dynamic library libcusparse.so.11\n",
      "2021-06-09 19:48:32.022445: I tensorflow/stream_executor/platform/default/dso_loader.cc:49] Successfully opened dynamic library libcudnn.so.8\n",
      "2021-06-09 19:48:32.030879: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1889] Adding visible gpu devices: 0, 1, 2, 3\n",
      "2021-06-09 19:48:32.032680: I tensorflow/compiler/jit/xla_gpu_device.cc:99] Not creating XLA devices, tf_xla_enable_xla_devices not set\n",
      "2021-06-09 19:48:33.010741: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1747] Found device 0 with properties: \n",
      "pciBusID: 0000:07:00.0 name: Tesla V100-DGXS-16GB computeCapability: 7.0\n",
      "coreClock: 1.53GHz coreCount: 80 deviceMemorySize: 15.78GiB deviceMemoryBandwidth: 836.37GiB/s\n",
      "2021-06-09 19:48:33.011970: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1747] Found device 1 with properties: \n",
      "pciBusID: 0000:08:00.0 name: Tesla V100-DGXS-16GB computeCapability: 7.0\n",
      "coreClock: 1.53GHz coreCount: 80 deviceMemorySize: 15.78GiB deviceMemoryBandwidth: 836.37GiB/s\n",
      "2021-06-09 19:48:33.013195: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1747] Found device 2 with properties: \n",
      "pciBusID: 0000:0e:00.0 name: Tesla V100-DGXS-16GB computeCapability: 7.0\n",
      "coreClock: 1.53GHz coreCount: 80 deviceMemorySize: 15.78GiB deviceMemoryBandwidth: 836.37GiB/s\n",
      "2021-06-09 19:48:33.014389: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1747] Found device 3 with properties: \n",
      "pciBusID: 0000:0f:00.0 name: Tesla V100-DGXS-16GB computeCapability: 7.0\n",
      "coreClock: 1.53GHz coreCount: 80 deviceMemorySize: 15.78GiB deviceMemoryBandwidth: 836.37GiB/s\n",
      "2021-06-09 19:48:33.014428: I tensorflow/stream_executor/platform/default/dso_loader.cc:49] Successfully opened dynamic library libcudart.so.11.0\n",
      "2021-06-09 19:48:33.014458: I tensorflow/stream_executor/platform/default/dso_loader.cc:49] Successfully opened dynamic library libcublas.so.11\n",
      "2021-06-09 19:48:33.014478: I tensorflow/stream_executor/platform/default/dso_loader.cc:49] Successfully opened dynamic library libcublasLt.so.11\n",
      "2021-06-09 19:48:33.014497: I tensorflow/stream_executor/platform/default/dso_loader.cc:49] Successfully opened dynamic library libcufft.so.10\n",
      "2021-06-09 19:48:33.014516: I tensorflow/stream_executor/platform/default/dso_loader.cc:49] Successfully opened dynamic library libcurand.so.10\n",
      "2021-06-09 19:48:33.014534: I tensorflow/stream_executor/platform/default/dso_loader.cc:49] Successfully opened dynamic library libcusolver.so.11\n",
      "2021-06-09 19:48:33.014552: I tensorflow/stream_executor/platform/default/dso_loader.cc:49] Successfully opened dynamic library libcusparse.so.11\n",
      "2021-06-09 19:48:33.014571: I tensorflow/stream_executor/platform/default/dso_loader.cc:49] Successfully opened dynamic library libcudnn.so.8\n",
      "2021-06-09 19:48:33.022970: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1889] Adding visible gpu devices: 0, 1, 2, 3\n",
      "2021-06-09 19:48:33.023016: I tensorflow/stream_executor/platform/default/dso_loader.cc:49] Successfully opened dynamic library libcudart.so.11.0\n",
      "2021-06-09 19:48:35.609734: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1287] Device interconnect StreamExecutor with strength 1 edge matrix:\n",
      "2021-06-09 19:48:35.609783: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1293]      0 1 2 3 \n",
      "2021-06-09 19:48:35.609797: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1306] 0:   N Y Y Y \n",
      "2021-06-09 19:48:35.609806: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1306] 1:   Y N Y Y \n",
      "2021-06-09 19:48:35.609816: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1306] 2:   Y Y N Y \n",
      "2021-06-09 19:48:35.609825: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1306] 3:   Y Y Y N \n",
      "2021-06-09 19:48:35.619000: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1432] Created TensorFlow device (/job:localhost/replica:0/task:0/device:GPU:0 with 203 MB memory) -> physical GPU (device: 0, name: Tesla V100-DGXS-16GB, pci bus id: 0000:07:00.0, compute capability: 7.0)\n",
      "2021-06-09 19:48:35.620513: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1432] Created TensorFlow device (/job:localhost/replica:0/task:0/device:GPU:1 with 14206 MB memory) -> physical GPU (device: 1, name: Tesla V100-DGXS-16GB, pci bus id: 0000:08:00.0, compute capability: 7.0)\n",
      "2021-06-09 19:48:35.621962: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1432] Created TensorFlow device (/job:localhost/replica:0/task:0/device:GPU:2 with 14206 MB memory) -> physical GPU (device: 2, name: Tesla V100-DGXS-16GB, pci bus id: 0000:0e:00.0, compute capability: 7.0)\n",
      "2021-06-09 19:48:35.623398: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1432] Created TensorFlow device (/job:localhost/replica:0/task:0/device:GPU:3 with 14206 MB memory) -> physical GPU (device: 3, name: Tesla V100-DGXS-16GB, pci bus id: 0000:0f:00.0, compute capability: 7.0)\n",
      "2021-06-09 19:48:35,625 - WARNING - '--tag' not specified for saved_model. Using --tag serve\n",
      "2021-06-09 19:48:43,221 - INFO - Signatures found in model: [serving_default].\n",
      "2021-06-09 19:48:43,221 - WARNING - '--signature_def' not specified, using first signature: serving_default\n",
      "2021-06-09 19:48:43,222 - INFO - Output names: ['predictions']\n",
      "2021-06-09 19:48:43.250962: I tensorflow/core/grappler/devices.cc:69] Number of eligible GPUs (core count >= 8, compute capability >= 0.0): 4\n",
      "2021-06-09 19:48:43.251124: I tensorflow/core/grappler/clusters/single_machine.cc:356] Starting new session\n",
      "2021-06-09 19:48:43.251388: I tensorflow/compiler/jit/xla_gpu_device.cc:99] Not creating XLA devices, tf_xla_enable_xla_devices not set\n",
      "2021-06-09 19:48:43.252059: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1747] Found device 0 with properties: \n",
      "pciBusID: 0000:07:00.0 name: Tesla V100-DGXS-16GB computeCapability: 7.0\n",
      "coreClock: 1.53GHz coreCount: 80 deviceMemorySize: 15.78GiB deviceMemoryBandwidth: 836.37GiB/s\n",
      "2021-06-09 19:48:43.253259: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1747] Found device 1 with properties: \n",
      "pciBusID: 0000:08:00.0 name: Tesla V100-DGXS-16GB computeCapability: 7.0\n",
      "coreClock: 1.53GHz coreCount: 80 deviceMemorySize: 15.78GiB deviceMemoryBandwidth: 836.37GiB/s\n",
      "2021-06-09 19:48:43.254444: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1747] Found device 2 with properties: \n",
      "pciBusID: 0000:0e:00.0 name: Tesla V100-DGXS-16GB computeCapability: 7.0\n",
      "coreClock: 1.53GHz coreCount: 80 deviceMemorySize: 15.78GiB deviceMemoryBandwidth: 836.37GiB/s\n",
      "2021-06-09 19:48:43.255627: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1747] Found device 3 with properties: \n",
      "pciBusID: 0000:0f:00.0 name: Tesla V100-DGXS-16GB computeCapability: 7.0\n",
      "coreClock: 1.53GHz coreCount: 80 deviceMemorySize: 15.78GiB deviceMemoryBandwidth: 836.37GiB/s\n",
      "2021-06-09 19:48:43.255663: I tensorflow/stream_executor/platform/default/dso_loader.cc:49] Successfully opened dynamic library libcudart.so.11.0\n",
      "2021-06-09 19:48:43.255693: I tensorflow/stream_executor/platform/default/dso_loader.cc:49] Successfully opened dynamic library libcublas.so.11\n",
      "2021-06-09 19:48:43.255712: I tensorflow/stream_executor/platform/default/dso_loader.cc:49] Successfully opened dynamic library libcublasLt.so.11\n",
      "2021-06-09 19:48:43.255730: I tensorflow/stream_executor/platform/default/dso_loader.cc:49] Successfully opened dynamic library libcufft.so.10\n",
      "2021-06-09 19:48:43.255748: I tensorflow/stream_executor/platform/default/dso_loader.cc:49] Successfully opened dynamic library libcurand.so.10\n",
      "2021-06-09 19:48:43.255765: I tensorflow/stream_executor/platform/default/dso_loader.cc:49] Successfully opened dynamic library libcusolver.so.11\n",
      "2021-06-09 19:48:43.255783: I tensorflow/stream_executor/platform/default/dso_loader.cc:49] Successfully opened dynamic library libcusparse.so.11\n",
      "2021-06-09 19:48:43.255801: I tensorflow/stream_executor/platform/default/dso_loader.cc:49] Successfully opened dynamic library libcudnn.so.8\n",
      "2021-06-09 19:48:43.264001: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1889] Adding visible gpu devices: 0, 1, 2, 3\n",
      "2021-06-09 19:48:43.264071: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1287] Device interconnect StreamExecutor with strength 1 edge matrix:\n",
      "2021-06-09 19:48:43.264086: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1293]      0 1 2 3 \n",
      "2021-06-09 19:48:43.264097: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1306] 0:   N Y Y Y \n",
      "2021-06-09 19:48:43.264106: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1306] 1:   Y N Y Y \n",
      "2021-06-09 19:48:43.264116: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1306] 2:   Y Y N Y \n",
      "2021-06-09 19:48:43.264125: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1306] 3:   Y Y Y N \n",
      "2021-06-09 19:48:43.269085: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1432] Created TensorFlow device (/job:localhost/replica:0/task:0/device:GPU:0 with 203 MB memory) -> physical GPU (device: 0, name: Tesla V100-DGXS-16GB, pci bus id: 0000:07:00.0, compute capability: 7.0)\n",
      "2021-06-09 19:48:43.270297: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1432] Created TensorFlow device (/job:localhost/replica:0/task:0/device:GPU:1 with 14206 MB memory) -> physical GPU (device: 1, name: Tesla V100-DGXS-16GB, pci bus id: 0000:08:00.0, compute capability: 7.0)\n",
      "2021-06-09 19:48:43.271732: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1432] Created TensorFlow device (/job:localhost/replica:0/task:0/device:GPU:2 with 14206 MB memory) -> physical GPU (device: 2, name: Tesla V100-DGXS-16GB, pci bus id: 0000:0e:00.0, compute capability: 7.0)\n",
      "2021-06-09 19:48:43.273448: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1432] Created TensorFlow device (/job:localhost/replica:0/task:0/device:GPU:3 with 14206 MB memory) -> physical GPU (device: 3, name: Tesla V100-DGXS-16GB, pci bus id: 0000:0f:00.0, compute capability: 7.0)\n",
      "2021-06-09 19:48:43.293134: I tensorflow/core/platform/profile_utils/cpu_utils.cc:112] CPU Frequency: 2198860000 Hz\n",
      "2021-06-09 19:48:43.355209: I tensorflow/core/grappler/optimizers/meta_optimizer.cc:954] Optimization results for grappler item: graph_to_optimize\n",
      "  function_optimizer: Graph size after: 1253 nodes (930), 1908 edges (1585), time = 33.193ms.\n",
      "  function_optimizer: function_optimizer did nothing. time = 0.577ms.\n",
      "\n",
      "2021-06-09 19:48:46.008484: I tensorflow/compiler/jit/xla_gpu_device.cc:99] Not creating XLA devices, tf_xla_enable_xla_devices not set\n",
      "2021-06-09 19:48:46.031017: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1747] Found device 0 with properties: \n",
      "pciBusID: 0000:07:00.0 name: Tesla V100-DGXS-16GB computeCapability: 7.0\n",
      "coreClock: 1.53GHz coreCount: 80 deviceMemorySize: 15.78GiB deviceMemoryBandwidth: 836.37GiB/s\n",
      "2021-06-09 19:48:46.033674: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1747] Found device 1 with properties: \n",
      "pciBusID: 0000:08:00.0 name: Tesla V100-DGXS-16GB computeCapability: 7.0\n",
      "coreClock: 1.53GHz coreCount: 80 deviceMemorySize: 15.78GiB deviceMemoryBandwidth: 836.37GiB/s\n",
      "2021-06-09 19:48:46.035311: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1747] Found device 2 with properties: \n",
      "pciBusID: 0000:0e:00.0 name: Tesla V100-DGXS-16GB computeCapability: 7.0\n",
      "coreClock: 1.53GHz coreCount: 80 deviceMemorySize: 15.78GiB deviceMemoryBandwidth: 836.37GiB/s\n",
      "2021-06-09 19:48:46.036940: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1747] Found device 3 with properties: \n",
      "pciBusID: 0000:0f:00.0 name: Tesla V100-DGXS-16GB computeCapability: 7.0\n",
      "coreClock: 1.53GHz coreCount: 80 deviceMemorySize: 15.78GiB deviceMemoryBandwidth: 836.37GiB/s\n",
      "2021-06-09 19:48:46.036986: I tensorflow/stream_executor/platform/default/dso_loader.cc:49] Successfully opened dynamic library libcudart.so.11.0\n",
      "2021-06-09 19:48:46.037035: I tensorflow/stream_executor/platform/default/dso_loader.cc:49] Successfully opened dynamic library libcublas.so.11\n",
      "2021-06-09 19:48:46.037062: I tensorflow/stream_executor/platform/default/dso_loader.cc:49] Successfully opened dynamic library libcublasLt.so.11\n",
      "2021-06-09 19:48:46.037086: I tensorflow/stream_executor/platform/default/dso_loader.cc:49] Successfully opened dynamic library libcufft.so.10\n",
      "2021-06-09 19:48:46.037110: I tensorflow/stream_executor/platform/default/dso_loader.cc:49] Successfully opened dynamic library libcurand.so.10\n",
      "2021-06-09 19:48:46.037133: I tensorflow/stream_executor/platform/default/dso_loader.cc:49] Successfully opened dynamic library libcusolver.so.11\n",
      "2021-06-09 19:48:46.037157: I tensorflow/stream_executor/platform/default/dso_loader.cc:49] Successfully opened dynamic library libcusparse.so.11\n",
      "2021-06-09 19:48:46.037181: I tensorflow/stream_executor/platform/default/dso_loader.cc:49] Successfully opened dynamic library libcudnn.so.8\n",
      "2021-06-09 19:48:46.046998: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1889] Adding visible gpu devices: 0, 1, 2, 3\n",
      "2021-06-09 19:48:46.047077: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1287] Device interconnect StreamExecutor with strength 1 edge matrix:\n",
      "2021-06-09 19:48:46.047095: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1293]      0 1 2 3 \n",
      "2021-06-09 19:48:46.047108: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1306] 0:   N Y Y Y \n",
      "2021-06-09 19:48:46.047120: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1306] 1:   Y N Y Y \n",
      "2021-06-09 19:48:46.047131: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1306] 2:   Y Y N Y \n",
      "2021-06-09 19:48:46.047142: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1306] 3:   Y Y Y N \n",
      "2021-06-09 19:48:46.052418: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1432] Created TensorFlow device (/job:localhost/replica:0/task:0/device:GPU:0 with 203 MB memory) -> physical GPU (device: 0, name: Tesla V100-DGXS-16GB, pci bus id: 0000:07:00.0, compute capability: 7.0)\n",
      "2021-06-09 19:48:46.053664: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1432] Created TensorFlow device (/job:localhost/replica:0/task:0/device:GPU:1 with 14206 MB memory) -> physical GPU (device: 1, name: Tesla V100-DGXS-16GB, pci bus id: 0000:08:00.0, compute capability: 7.0)\n",
      "2021-06-09 19:48:46.054881: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1432] Created TensorFlow device (/job:localhost/replica:0/task:0/device:GPU:2 with 14206 MB memory) -> physical GPU (device: 2, name: Tesla V100-DGXS-16GB, pci bus id: 0000:0e:00.0, compute capability: 7.0)\n",
      "2021-06-09 19:48:46.056098: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1432] Created TensorFlow device (/job:localhost/replica:0/task:0/device:GPU:3 with 14206 MB memory) -> physical GPU (device: 3, name: Tesla V100-DGXS-16GB, pci bus id: 0000:0f:00.0, compute capability: 7.0)\n",
      "WARNING:tensorflow:From /usr/local/lib/python3.8/dist-packages/tf2onnx/tf_loader.py:603: extract_sub_graph (from tensorflow.python.framework.graph_util_impl) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use `tf.compat.v1.graph_util.extract_sub_graph`\n",
      "2021-06-09 19:48:46,541 - WARNING - From /usr/local/lib/python3.8/dist-packages/tf2onnx/tf_loader.py:603: extract_sub_graph (from tensorflow.python.framework.graph_util_impl) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use `tf.compat.v1.graph_util.extract_sub_graph`\n",
      "2021-06-09 19:48:46.600644: I tensorflow/core/grappler/devices.cc:69] Number of eligible GPUs (core count >= 8, compute capability >= 0.0): 4\n",
      "2021-06-09 19:48:46.600797: I tensorflow/core/grappler/clusters/single_machine.cc:356] Starting new session\n",
      "2021-06-09 19:48:46.601148: I tensorflow/compiler/jit/xla_gpu_device.cc:99] Not creating XLA devices, tf_xla_enable_xla_devices not set\n",
      "2021-06-09 19:48:46.602435: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1747] Found device 0 with properties: \n",
      "pciBusID: 0000:07:00.0 name: Tesla V100-DGXS-16GB computeCapability: 7.0\n",
      "coreClock: 1.53GHz coreCount: 80 deviceMemorySize: 15.78GiB deviceMemoryBandwidth: 836.37GiB/s\n",
      "2021-06-09 19:48:46.604322: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1747] Found device 1 with properties: \n",
      "pciBusID: 0000:08:00.0 name: Tesla V100-DGXS-16GB computeCapability: 7.0\n",
      "coreClock: 1.53GHz coreCount: 80 deviceMemorySize: 15.78GiB deviceMemoryBandwidth: 836.37GiB/s\n",
      "2021-06-09 19:48:46.606193: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1747] Found device 2 with properties: \n",
      "pciBusID: 0000:0e:00.0 name: Tesla V100-DGXS-16GB computeCapability: 7.0\n",
      "coreClock: 1.53GHz coreCount: 80 deviceMemorySize: 15.78GiB deviceMemoryBandwidth: 836.37GiB/s\n",
      "2021-06-09 19:48:46.608049: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1747] Found device 3 with properties: \n",
      "pciBusID: 0000:0f:00.0 name: Tesla V100-DGXS-16GB computeCapability: 7.0\n",
      "coreClock: 1.53GHz coreCount: 80 deviceMemorySize: 15.78GiB deviceMemoryBandwidth: 836.37GiB/s\n",
      "2021-06-09 19:48:46.608091: I tensorflow/stream_executor/platform/default/dso_loader.cc:49] Successfully opened dynamic library libcudart.so.11.0\n",
      "2021-06-09 19:48:46.608129: I tensorflow/stream_executor/platform/default/dso_loader.cc:49] Successfully opened dynamic library libcublas.so.11\n",
      "2021-06-09 19:48:46.608153: I tensorflow/stream_executor/platform/default/dso_loader.cc:49] Successfully opened dynamic library libcublasLt.so.11\n",
      "2021-06-09 19:48:46.608176: I tensorflow/stream_executor/platform/default/dso_loader.cc:49] Successfully opened dynamic library libcufft.so.10\n",
      "2021-06-09 19:48:46.608198: I tensorflow/stream_executor/platform/default/dso_loader.cc:49] Successfully opened dynamic library libcurand.so.10\n",
      "2021-06-09 19:48:46.608220: I tensorflow/stream_executor/platform/default/dso_loader.cc:49] Successfully opened dynamic library libcusolver.so.11\n",
      "2021-06-09 19:48:46.608242: I tensorflow/stream_executor/platform/default/dso_loader.cc:49] Successfully opened dynamic library libcusparse.so.11\n",
      "2021-06-09 19:48:46.608265: I tensorflow/stream_executor/platform/default/dso_loader.cc:49] Successfully opened dynamic library libcudnn.so.8\n",
      "2021-06-09 19:48:46.625482: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1889] Adding visible gpu devices: 0, 1, 2, 3\n",
      "2021-06-09 19:48:46.625560: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1287] Device interconnect StreamExecutor with strength 1 edge matrix:\n",
      "2021-06-09 19:48:46.625578: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1293]      0 1 2 3 \n",
      "2021-06-09 19:48:46.625590: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1306] 0:   N Y Y Y \n",
      "2021-06-09 19:48:46.625601: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1306] 1:   Y N Y Y \n",
      "2021-06-09 19:48:46.625612: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1306] 2:   Y Y N Y \n",
      "2021-06-09 19:48:46.625623: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1306] 3:   Y Y Y N \n",
      "2021-06-09 19:48:46.634557: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1432] Created TensorFlow device (/job:localhost/replica:0/task:0/device:GPU:0 with 203 MB memory) -> physical GPU (device: 0, name: Tesla V100-DGXS-16GB, pci bus id: 0000:07:00.0, compute capability: 7.0)\n",
      "2021-06-09 19:48:46.636578: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1432] Created TensorFlow device (/job:localhost/replica:0/task:0/device:GPU:1 with 14206 MB memory) -> physical GPU (device: 1, name: Tesla V100-DGXS-16GB, pci bus id: 0000:08:00.0, compute capability: 7.0)\n",
      "2021-06-09 19:48:46.638422: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1432] Created TensorFlow device (/job:localhost/replica:0/task:0/device:GPU:2 with 14206 MB memory) -> physical GPU (device: 2, name: Tesla V100-DGXS-16GB, pci bus id: 0000:0e:00.0, compute capability: 7.0)\n",
      "2021-06-09 19:48:46.640290: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1432] Created TensorFlow device (/job:localhost/replica:0/task:0/device:GPU:3 with 14206 MB memory) -> physical GPU (device: 3, name: Tesla V100-DGXS-16GB, pci bus id: 0000:0f:00.0, compute capability: 7.0)\n",
      "2021-06-09 19:48:47.379855: I tensorflow/core/grappler/optimizers/meta_optimizer.cc:954] Optimization results for grappler item: graph_to_optimize\n",
      "  constant_folding: Graph size after: 560 nodes (-640), 1215 edges (-640), time = 399.986ms.\n",
      "  function_optimizer: function_optimizer did nothing. time = 1.17ms.\n",
      "  constant_folding: Graph size after: 560 nodes (0), 1215 edges (0), time = 101.728ms.\n",
      "  function_optimizer: function_optimizer did nothing. time = 1.017ms.\n",
      "\n",
      "2021-06-09 19:48:47,938 - INFO - Using tensorflow=2.4.0, onnx=1.9.0, tf2onnx=1.8.5/50049d\n",
      "2021-06-09 19:48:47,939 - INFO - Using opset <onnx, 9>\n",
      "2021-06-09 19:48:52,720 - INFO - Computed 0 values for constant folding\n",
      "2021-06-09 19:49:05,218 - INFO - Optimizing ONNX model\n",
      "2021-06-09 19:49:06,920 - INFO - After optimization: Add -1 (18->17), BatchNormalization -53 (53->0), Const -162 (270->108), GlobalAveragePool +1 (0->1), Identity -57 (57->0), ReduceMean -1 (1->0), Squeeze +1 (0->1), Transpose -213 (214->1)\n",
      "2021-06-09 19:49:07,076 - INFO - \n",
      "2021-06-09 19:49:07,076 - INFO - Successfully converted TensorFlow model my_model to ONNX\n",
      "2021-06-09 19:49:07,076 - INFO - Model inputs: ['input_1:0']\n",
      "2021-06-09 19:49:07,076 - INFO - Model outputs: ['predictions']\n",
      "2021-06-09 19:49:07,076 - INFO - ONNX model is saved at temp.onnx\n"
     ]
    }
   ],
   "source": [
    "model.save('my_model')\n",
    "!python -m tf2onnx.convert --saved-model my_model --output temp.onnx\n",
    "onnx_model = onnx.load_model('temp.onnx')\n",
    "\n",
    "# This can also be done with keras2onnx:\n",
    "# onnx_model = keras2onnx.convert_keras(model, model.name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That said, we do need to make one change for our model to work with TensorRT. Keras by default uses a dynamic input shape in its networks - where it can handle arbitrary batch sizes at every update. While TensorRT can do this, it requires extra configuration. \n",
    "\n",
    "Instead, we will just set the input size to be fixed to our batch size. This will work with TensorRT out of the box!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Configure ONNX File Batch Size:__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Note:__ We need to do two things to set our batch size with ONNX. The first is to modify our ONNX file to change its default batch size to our target batch size. The second is setting our converter to use the __explicit batch__ mode, which will use this default batch size as our final batch size."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "inputs = onnx_model.graph.input\n",
    "for input in inputs:\n",
    "    dim1 = input.type.tensor_type.shape.dim[0]\n",
    "    dim1.dim_value = BATCH_SIZE"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Save Model:__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "id": "jFT6-13f8qup"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Done saving!\n"
     ]
    }
   ],
   "source": [
    "model_name = \"resnet50_onnx_model.onnx\"\n",
    "onnx.save_model(onnx_model, model_name)\n",
    "print(\"Done saving!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once we get our model into ONNX format, we can convert it efficiently using TensorRT. For this, TensorRT needs exclusive access to your GPU. If you so much as import Tensorflow, it will generally consume all of your GPU memory. To get around this, before moving on go ahead and shut down this notebook and restart it. (You can do this in the menu: Kernel -> Restart Kernel)\n",
    "\n",
    "Make sure not to import Tensorflow at any point after restarting the runtime! \n",
    "\n",
    "(The following cell is a quick shortcut to make your notebook restart:)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "uZUnHVHE8quu"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Restarting kernel  in three seconds...\n"
     ]
    }
   ],
   "source": [
    "import os, time\n",
    "print(\"Restarting kernel  in three seconds...\")\n",
    "time.sleep(3)\n",
    "print(\"Restarting kernel now\")\n",
    "os._exit(0) # Shut down all kernels so TRT doesn't fight with Tensorflow for GPU memory - TF monopolizes all GPU memory by default"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. What batch size(s) am I running inference at?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We have actually already set our inference batch size - see the note above in section 1!\n",
    "\n",
    "We are going to set our target batch size to a fixed size of 32."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "BATCH_SIZE = 32"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We need to do two things to set our batch size to a fixed batch size with ONNX: \n",
    "\n",
    "1. Modify our ONNX file to change its default batch size to our target batch size, which we did above.\n",
    "2. Use the trtexec --explicitBatch flag, which we also did above."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. What precision am I running inference at?\n",
    "\n",
    "Now, we have a converted TensorRT engine. Great! That means we are ready to load it into the native Python TensorRT runtime. This runtime strikes a balance between the ease of use of the high level Python runtimes and the low level C++ runtimes.\n",
    "\n",
    "First, as before, lets create a dummy batch. Importantly, by default TensorRT will use the input precision you give it as the default precision for the rest of the network. \n",
    "\n",
    "Remember that lower precisions than FP32 tend to run faster. There are two common reduced precision modes - FP16 and INT8. Graphics cards that are designed to do inference well often have an affinity for one of these two types. This guide was developed on an NVIDIA V100, which favors FP16, so we will use that here by default. INT8 is a more complicated process that requires a calibration step."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "USE_FP16 = True\n",
    "\n",
    "target_dtype = np.float16 if USE_FP16 else np.float32"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We generate a batch of repeating Golden Retriever images, as before. Make sure that for TensorRT the image is resized to the size your model expects. Tensorflow and TensorRT have different behavior for handling 'oversized' images - so this is a safe way of ensuring consistent results across the two."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "from skimage import io\n",
    "from skimage.transform import resize\n",
    "from matplotlib import pyplot as plt\n",
    "\n",
    "url='https://images.dog.ceo/breeds/retriever-golden/n02099601_3004.jpg'\n",
    "img = resize(io.imread(url), (224, 224))\n",
    "input_batch = 255*np.array(np.repeat(np.expand_dims(np.array(img, dtype=np.float32), axis=0), BATCH_SIZE, axis=0), dtype=np.float32)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Only we must now cast the input batch to the proper FP32/FP16 precision:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "input_batch = input_batch.astype(target_dtype)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. What TensorRT path am I using to convert my model?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "TensorRT is able to take ONNX models and convert them entirely into a single, efficient TensorRT engine. Restart your Jupyter kernel, and then start here!\n",
    "\n",
    "We can use trtexec, a command line tool for working with TensorRT, in order to convert an ONNX model to an engine file.\n",
    "\n",
    "To convert the model we saved in the previous steps, we need to point to the ONNX file, give trtexec a name to save the engine as, and last specify that we want to use a fixed batch size instead of a dynamic one.\n",
    "\n",
    "__Remember to shut down all Jupyter notebooks and restart your Jupyter kernel after \"1. What format should I save my model in?\" - otherwise this cell will crash as TensorRT competes with Tensorflow for GPU memory:__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "h60Gmotx8quz",
    "outputId": "065384aa-c848-4194-c72c-cad0d80449ca"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "&&&& RUNNING TensorRT.trtexec # trtexec --onnx=resnet50_onnx_model.onnx --saveEngine=resnet_engine.trt --explicitBatch --inputIOFormats=fp16:chw --outputIOFormats=fp16:chw --fp16\n",
      "[06/09/2021-19:49:25] [I] === Model Options ===\n",
      "[06/09/2021-19:49:25] [I] Format: ONNX\n",
      "[06/09/2021-19:49:25] [I] Model: resnet50_onnx_model.onnx\n",
      "[06/09/2021-19:49:25] [I] Output:\n",
      "[06/09/2021-19:49:25] [I] === Build Options ===\n",
      "[06/09/2021-19:49:25] [I] Max batch: explicit\n",
      "[06/09/2021-19:49:25] [I] Workspace: 16 MiB\n",
      "[06/09/2021-19:49:25] [I] minTiming: 1\n",
      "[06/09/2021-19:49:25] [I] avgTiming: 8\n",
      "[06/09/2021-19:49:25] [I] Precision: FP32+FP16\n",
      "[06/09/2021-19:49:25] [I] Calibration: \n",
      "[06/09/2021-19:49:25] [I] Refit: Disabled\n",
      "[06/09/2021-19:49:25] [I] Safe mode: Disabled\n",
      "[06/09/2021-19:49:25] [I] Save engine: resnet_engine.trt\n",
      "[06/09/2021-19:49:25] [I] Load engine: \n",
      "[06/09/2021-19:49:25] [I] Builder Cache: Enabled\n",
      "[06/09/2021-19:49:25] [I] NVTX verbosity: 0\n",
      "[06/09/2021-19:49:25] [I] Tactic sources: Using default tactic sources\n",
      "[06/09/2021-19:49:25] [I] Input(s): fp16:chw\n",
      "[06/09/2021-19:49:25] [I] Output(s): fp16:chw\n",
      "[06/09/2021-19:49:25] [I] Input build shapes: model\n",
      "[06/09/2021-19:49:25] [I] Input calibration shapes: model\n",
      "[06/09/2021-19:49:25] [I] === System Options ===\n",
      "[06/09/2021-19:49:25] [I] Device: 0\n",
      "[06/09/2021-19:49:25] [I] DLACore: \n",
      "[06/09/2021-19:49:25] [I] Plugins:\n",
      "[06/09/2021-19:49:25] [I] === Inference Options ===\n",
      "[06/09/2021-19:49:25] [I] Batch: Explicit\n",
      "[06/09/2021-19:49:25] [I] Input inference shapes: model\n",
      "[06/09/2021-19:49:25] [I] Iterations: 10\n",
      "[06/09/2021-19:49:25] [I] Duration: 3s (+ 200ms warm up)\n",
      "[06/09/2021-19:49:25] [I] Sleep time: 0ms\n",
      "[06/09/2021-19:49:25] [I] Streams: 1\n",
      "[06/09/2021-19:49:25] [I] ExposeDMA: Disabled\n",
      "[06/09/2021-19:49:25] [I] Data transfers: Enabled\n",
      "[06/09/2021-19:49:25] [I] Spin-wait: Disabled\n",
      "[06/09/2021-19:49:25] [I] Multithreading: Disabled\n",
      "[06/09/2021-19:49:25] [I] CUDA Graph: Disabled\n",
      "[06/09/2021-19:49:25] [I] Separate profiling: Disabled\n",
      "[06/09/2021-19:49:25] [I] Skip inference: Disabled\n",
      "[06/09/2021-19:49:25] [I] Inputs:\n",
      "[06/09/2021-19:49:25] [I] === Reporting Options ===\n",
      "[06/09/2021-19:49:25] [I] Verbose: Disabled\n",
      "[06/09/2021-19:49:25] [I] Averages: 10 inferences\n",
      "[06/09/2021-19:49:25] [I] Percentile: 99\n",
      "[06/09/2021-19:49:25] [I] Dump refittable layers:Disabled\n",
      "[06/09/2021-19:49:25] [I] Dump output: Disabled\n",
      "[06/09/2021-19:49:25] [I] Profile: Disabled\n",
      "[06/09/2021-19:49:25] [I] Export timing to JSON file: \n",
      "[06/09/2021-19:49:25] [I] Export output to JSON file: \n",
      "[06/09/2021-19:49:25] [I] Export profile to JSON file: \n",
      "[06/09/2021-19:49:25] [I] \n",
      "[06/09/2021-19:49:25] [I] === Device Information ===\n",
      "[06/09/2021-19:49:25] [I] Selected Device: Tesla V100-DGXS-16GB\n",
      "[06/09/2021-19:49:25] [I] Compute Capability: 7.0\n",
      "[06/09/2021-19:49:25] [I] SMs: 80\n",
      "[06/09/2021-19:49:25] [I] Compute Clock Rate: 1.53 GHz\n",
      "[06/09/2021-19:49:25] [I] Device Global Memory: 16155 MiB\n",
      "[06/09/2021-19:49:25] [I] Shared Memory per SM: 96 KiB\n",
      "[06/09/2021-19:49:25] [I] Memory Bus Width: 4096 bits (ECC enabled)\n",
      "[06/09/2021-19:49:25] [I] Memory Clock Rate: 0.877 GHz\n",
      "[06/09/2021-19:49:25] [I] \n",
      "[06/09/2021-19:49:42] [I] [TRT] ----------------------------------------------------------------\n",
      "[06/09/2021-19:49:42] [I] [TRT] Input filename:   resnet50_onnx_model.onnx\n",
      "[06/09/2021-19:49:42] [I] [TRT] ONNX IR version:  0.0.4\n",
      "[06/09/2021-19:49:42] [I] [TRT] Opset version:    9\n",
      "[06/09/2021-19:49:42] [I] [TRT] Producer name:    tf2onnx\n",
      "[06/09/2021-19:49:42] [I] [TRT] Producer version: 1.8.5\n",
      "[06/09/2021-19:49:42] [I] [TRT] Domain:           \n",
      "[06/09/2021-19:49:42] [I] [TRT] Model version:    0\n",
      "[06/09/2021-19:49:42] [I] [TRT] Doc string:       \n",
      "[06/09/2021-19:49:42] [I] [TRT] ----------------------------------------------------------------\n",
      "[06/09/2021-19:49:48] [I] [TRT] Some tactics do not have sufficient workspace memory to run. Increasing workspace size may increase performance, please check verbose output.\n",
      "[06/09/2021-19:51:05] [I] [TRT] Detected 1 inputs and 1 output network tensors.\n",
      "[06/09/2021-19:51:06] [I] Engine built in 100.683 sec.\n",
      "[06/09/2021-19:51:06] [I] Starting inference\n",
      "[06/09/2021-19:51:09] [I] Warmup completed 0 queries over 200 ms\n",
      "[06/09/2021-19:51:09] [I] Timing trace has 0 queries over 2.99006 s\n",
      "[06/09/2021-19:51:09] [I] Trace averages of 10 runs:\n",
      "[06/09/2021-19:51:09] [I] Average on 10 runs - GPU latency: 5.48546 ms - Host latency: 6.30948 ms (end to end 10.0032 ms, enqueue 0.539108 ms)\n",
      "[06/09/2021-19:51:09] [I] Average on 10 runs - GPU latency: 5.48946 ms - Host latency: 6.31468 ms (end to end 10.9038 ms, enqueue 0.516052 ms)\n",
      "[06/09/2021-19:51:09] [I] Average on 10 runs - GPU latency: 5.48004 ms - Host latency: 6.3107 ms (end to end 10.8822 ms, enqueue 0.513507 ms)\n",
      "[06/09/2021-19:51:09] [I] Average on 10 runs - GPU latency: 5.49315 ms - Host latency: 6.34006 ms (end to end 10.4643 ms, enqueue 0.512753 ms)\n",
      "[06/09/2021-19:51:09] [I] Average on 10 runs - GPU latency: 5.52059 ms - Host latency: 6.36953 ms (end to end 10.2954 ms, enqueue 0.498505 ms)\n",
      "[06/09/2021-19:51:09] [I] Average on 10 runs - GPU latency: 5.50788 ms - Host latency: 6.3551 ms (end to end 9.11696 ms, enqueue 0.518701 ms)\n",
      "[06/09/2021-19:51:09] [I] Average on 10 runs - GPU latency: 5.49774 ms - Host latency: 6.3454 ms (end to end 10.9278 ms, enqueue 0.495056 ms)\n",
      "[06/09/2021-19:51:09] [I] Average on 10 runs - GPU latency: 5.50585 ms - Host latency: 6.35638 ms (end to end 10.9322 ms, enqueue 0.505725 ms)\n",
      "[06/09/2021-19:51:09] [I] Average on 10 runs - GPU latency: 5.50247 ms - Host latency: 6.35249 ms (end to end 10.5564 ms, enqueue 0.513574 ms)\n",
      "[06/09/2021-19:51:09] [I] Average on 10 runs - GPU latency: 5.51249 ms - Host latency: 6.36059 ms (end to end 9.63242 ms, enqueue 0.498096 ms)\n",
      "[06/09/2021-19:51:09] [I] Average on 10 runs - GPU latency: 5.4911 ms - Host latency: 6.33875 ms (end to end 8.90275 ms, enqueue 0.474237 ms)\n",
      "[06/09/2021-19:51:09] [I] Average on 10 runs - GPU latency: 5.50072 ms - Host latency: 6.34651 ms (end to end 10.4826 ms, enqueue 0.498499 ms)\n",
      "[06/09/2021-19:51:09] [I] Average on 10 runs - GPU latency: 5.49602 ms - Host latency: 6.34083 ms (end to end 10.92 ms, enqueue 0.486401 ms)\n",
      "[06/09/2021-19:51:09] [I] Average on 10 runs - GPU latency: 5.49089 ms - Host latency: 6.3358 ms (end to end 10.8925 ms, enqueue 0.490247 ms)\n",
      "[06/09/2021-19:51:09] [I] Average on 10 runs - GPU latency: 5.48907 ms - Host latency: 6.33452 ms (end to end 10.1912 ms, enqueue 0.482959 ms)\n",
      "[06/09/2021-19:51:09] [I] Average on 10 runs - GPU latency: 5.47534 ms - Host latency: 6.31992 ms (end to end 8.9359 ms, enqueue 0.484119 ms)\n",
      "[06/09/2021-19:51:09] [I] Average on 10 runs - GPU latency: 5.47952 ms - Host latency: 6.32281 ms (end to end 10.4421 ms, enqueue 0.481885 ms)\n",
      "[06/09/2021-19:51:09] [I] Average on 10 runs - GPU latency: 5.48701 ms - Host latency: 6.33408 ms (end to end 10.9013 ms, enqueue 0.491455 ms)\n",
      "[06/09/2021-19:51:09] [I] Average on 10 runs - GPU latency: 5.48179 ms - Host latency: 6.33092 ms (end to end 10.885 ms, enqueue 0.505078 ms)\n",
      "[06/09/2021-19:51:09] [I] Average on 10 runs - GPU latency: 5.48776 ms - Host latency: 6.33756 ms (end to end 10.3106 ms, enqueue 0.494629 ms)\n",
      "[06/09/2021-19:51:09] [I] Average on 10 runs - GPU latency: 5.47145 ms - Host latency: 6.31754 ms (end to end 9.37426 ms, enqueue 0.481995 ms)\n",
      "[06/09/2021-19:51:09] [I] Average on 10 runs - GPU latency: 5.48057 ms - Host latency: 6.32472 ms (end to end 9.55609 ms, enqueue 0.480151 ms)\n",
      "[06/09/2021-19:51:09] [I] Average on 10 runs - GPU latency: 5.48557 ms - Host latency: 6.33252 ms (end to end 10.4543 ms, enqueue 0.486841 ms)\n",
      "[06/09/2021-19:51:09] [I] Average on 10 runs - GPU latency: 5.50972 ms - Host latency: 6.35627 ms (end to end 10.9478 ms, enqueue 0.488062 ms)\n",
      "[06/09/2021-19:51:09] [I] Average on 10 runs - GPU latency: 5.50054 ms - Host latency: 6.34517 ms (end to end 10.0418 ms, enqueue 0.483325 ms)\n",
      "[06/09/2021-19:51:09] [I] Average on 10 runs - GPU latency: 5.48201 ms - Host latency: 6.32832 ms (end to end 9.67512 ms, enqueue 0.481812 ms)\n",
      "[06/09/2021-19:51:09] [I] Average on 10 runs - GPU latency: 5.48279 ms - Host latency: 6.32742 ms (end to end 9.18972 ms, enqueue 0.484082 ms)\n",
      "[06/09/2021-19:51:09] [I] Average on 10 runs - GPU latency: 5.47712 ms - Host latency: 6.32109 ms (end to end 10.879 ms, enqueue 0.482202 ms)\n",
      "[06/09/2021-19:51:09] [I] Average on 10 runs - GPU latency: 5.47788 ms - Host latency: 6.32166 ms (end to end 10.8823 ms, enqueue 0.481006 ms)\n",
      "[06/09/2021-19:51:09] [I] Average on 10 runs - GPU latency: 5.48203 ms - Host latency: 6.32615 ms (end to end 10.6967 ms, enqueue 0.481055 ms)\n",
      "[06/09/2021-19:51:09] [I] Average on 10 runs - GPU latency: 5.46802 ms - Host latency: 6.31384 ms (end to end 9.47229 ms, enqueue 0.477344 ms)\n",
      "[06/09/2021-19:51:09] [I] Average on 10 runs - GPU latency: 5.4967 ms - Host latency: 6.3428 ms (end to end 8.9686 ms, enqueue 0.48147 ms)\n",
      "[06/09/2021-19:51:09] [I] Average on 10 runs - GPU latency: 5.49275 ms - Host latency: 6.33767 ms (end to end 9.57681 ms, enqueue 0.481714 ms)\n",
      "[06/09/2021-19:51:09] [I] Average on 10 runs - GPU latency: 5.52278 ms - Host latency: 6.37007 ms (end to end 10.9759 ms, enqueue 0.493896 ms)\n",
      "[06/09/2021-19:51:09] [I] Average on 10 runs - GPU latency: 5.49238 ms - Host latency: 6.34084 ms (end to end 10.7861 ms, enqueue 0.49917 ms)\n",
      "[06/09/2021-19:51:09] [I] Average on 10 runs - GPU latency: 5.48333 ms - Host latency: 6.33235 ms (end to end 10.4963 ms, enqueue 0.500806 ms)\n",
      "[06/09/2021-19:51:09] [I] Host Latency\n",
      "[06/09/2021-19:51:09] [I] min: 6.28442 ms (end to end 6.327 ms)\n",
      "[06/09/2021-19:51:09] [I] max: 6.66431 ms (end to end 11.2405 ms)\n",
      "[06/09/2021-19:51:09] [I] mean: 6.33588 ms (end to end 10.2251 ms)\n",
      "[06/09/2021-19:51:09] [I] median: 6.33411 ms (end to end 10.8945 ms)\n",
      "[06/09/2021-19:51:09] [I] percentile: 6.38745 ms at 99% (end to end 11.0925 ms at 99%)\n",
      "[06/09/2021-19:51:09] [I] throughput: 0 qps\n",
      "[06/09/2021-19:51:09] [I] walltime: 2.99006 s\n",
      "[06/09/2021-19:51:09] [I] Enqueue Time\n",
      "[06/09/2021-19:51:09] [I] min: 0.413086 ms\n",
      "[06/09/2021-19:51:09] [I] max: 0.796997 ms\n",
      "[06/09/2021-19:51:09] [I] median: 0.486877 ms\n",
      "[06/09/2021-19:51:09] [I] GPU Compute\n",
      "[06/09/2021-19:51:09] [I] min: 5.4425 ms\n",
      "[06/09/2021-19:51:09] [I] max: 5.82251 ms\n",
      "[06/09/2021-19:51:09] [I] mean: 5.49097 ms\n",
      "[06/09/2021-19:51:09] [I] median: 5.48969 ms\n",
      "[06/09/2021-19:51:09] [I] percentile: 5.53986 ms at 99%\n",
      "[06/09/2021-19:51:09] [I] total compute time: 2.00421 s\n",
      "&&&& PASSED TensorRT.trtexec # trtexec --onnx=resnet50_onnx_model.onnx --saveEngine=resnet_engine.trt --explicitBatch --inputIOFormats=fp16:chw --outputIOFormats=fp16:chw --fp16\n"
     ]
    }
   ],
   "source": [
    "# May need to shut down all kernels and restart before this - otherwise you might get cuDNN initialization errors:\n",
    "if USE_FP16:\n",
    "    !trtexec --onnx=resnet50_onnx_model.onnx --saveEngine=resnet_engine.trt  --explicitBatch --inputIOFormats=fp16:chw --outputIOFormats=fp16:chw --fp16\n",
    "else:\n",
    "    !trtexec --onnx=resnet50_onnx_model.onnx --saveEngine=resnet_engine.trt  --explicitBatch"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "-\n",
    "\n",
    "__The trtexec Logs:__\n",
    "\n",
    "Above, trtexec does a lot of things! Some important things to note:\n",
    "\n",
    "__First__, _\"PASSED\"_ is what you want to see in the last line of the log above. We can see our conversion was successful!\n",
    "\n",
    "__Second__, can see the resnet_engine.trt engine file has indeed been successfully created: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "total 508284\n",
      "drwxrwxr-x 8 1000 1000      4096 Jun  9 19:49  .\n",
      "drwxrwxr-x 5 1000 1000      4096 Apr  5 23:28  ..\n",
      "drwxr-xr-x 2 root root      4096 Apr  6 01:13  .ipynb_checkpoints\n",
      "-rw-rw-r-- 1 1000 1000     34748 Jun  9 19:46 '0. Running This Guide.ipynb'\n",
      "-rw-rw-r-- 1 1000 1000    502649 Apr  5 23:28 '1. Introduction.ipynb'\n",
      "-rw-rw-r-- 1 1000 1000     23645 Apr  5 23:28 '2. Using the Tensorflow TensorRT Integration.ipynb'\n",
      "-rw-rw-r-- 1 1000 1000    210995 Jun  9 19:49 '3. Using Tensorflow 2 through ONNX.ipynb'\n",
      "-rw-rw-r-- 1 1000 1000    334050 Jun  9 19:17 '4. Using PyTorch through ONNX.ipynb'\n",
      "-rw-rw-r-- 1 1000 1000      7052 Apr  5 23:28 '5. Understanding TensorRT Runtimes.ipynb'\n",
      "drwxrwxr-x 2 1000 1000      4096 Apr  5 23:28 'Additional Examples'\n",
      "drwxr-xr-x 2 root root      4096 Apr  5 23:28  Getting_Started\n",
      "drwxr-xr-x 2 root root      4096 Apr  6 01:09  __pycache__\n",
      "-rw-rw-r-- 1 1000 1000      4085 Apr  5 23:28  helper.py\n",
      "drwxrwxr-x 2 1000 1000      4096 Apr  5 23:28  images\n",
      "drwxr-xr-x 4 root root      4096 Jun  9 19:48  my_model\n",
      "-rw-rw-r-- 1 1000 1000      3228 Apr  5 23:28  onnx_helper.py\n",
      "-rw-r--r-- 1 root root 102169836 Jun  9 19:49  resnet50_onnx_model.onnx\n",
      "-rw-r--r-- 1 root root 102470353 Apr  6 04:18  resnet50_pytorch.onnx\n",
      "-rw-r--r-- 1 root root  51398352 Jun  9 19:51  resnet_engine.trt\n",
      "-rw-r--r-- 1 root root 161081907 Apr  6 17:38  resnet_engine_pytorch.trt\n",
      "-rw-r--r-- 1 root root 102169844 Jun  9 19:49  temp.onnx\n"
     ]
    }
   ],
   "source": [
    "!ls -la"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Third__, you can see timing details above using trtexec - these are in the ideal case with no overhead. Depending on how you run your model, a considerable amount of overhead can be added to this. We can do timing in our Python runtime below - but keep in mind performing C++ inference would likely be faster."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5. What TensorRT runtime am I targeting?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We want to run our TensorRT inference in Python - so the TensorRT Python API is a great way of testing our model out in Jupyter, and is still quite performant.\n",
    "\n",
    "To use it, we need to do a few steps:\n",
    "\n",
    "__Load our engine into a tensorrt.Runtime:__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "id": "dX2jFwrA8qu6"
   },
   "outputs": [],
   "source": [
    "import tensorrt as trt\n",
    "import pycuda.driver as cuda\n",
    "import pycuda.autoinit\n",
    "\n",
    "f = open(\"resnet_engine.trt\", \"rb\")\n",
    "runtime = trt.Runtime(trt.Logger(trt.Logger.WARNING)) \n",
    "\n",
    "engine = runtime.deserialize_cuda_engine(f.read())\n",
    "context = engine.create_execution_context()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note: if this cell is having issues, restarting all Jupyter kernels and rerunning only the batch size and precision cells above before trying again often helps"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Allocate input and output memory, give TRT pointers (bindings) to it:__\n",
    "\n",
    "d_input and d_output refer to the memory regions on our 'device' (aka GPU) - as opposed to memory on our normal RAM, where Python holds its variables (such as 'output' below)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "id": "q3UJcdWy8qu8"
   },
   "outputs": [],
   "source": [
    "output = np.empty([BATCH_SIZE, 1000], dtype = target_dtype) # Need to set output dtype to FP16 to enable FP16\n",
    "\n",
    "# Allocate device memory\n",
    "d_input = cuda.mem_alloc(1 * input_batch.nbytes)\n",
    "d_output = cuda.mem_alloc(1 * output.nbytes)\n",
    "\n",
    "bindings = [int(d_input), int(d_output)]\n",
    "\n",
    "stream = cuda.Stream()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Set up prediction function:__\n",
    "\n",
    "This involves a copy from CPU RAM to GPU VRAM, executing the model, then copying the results back from GPU VRAM to CPU RAM:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "id": "6R-F8JtV8qu-"
   },
   "outputs": [],
   "source": [
    "def predict(batch): # result gets copied into output\n",
    "    # Transfer input data to device\n",
    "    cuda.memcpy_htod_async(d_input, batch, stream)\n",
    "    # Execute model\n",
    "    context.execute_async_v2(bindings, stream.handle, None)\n",
    "    # Transfer predictions back\n",
    "    cuda.memcpy_dtoh_async(output, d_output, stream)\n",
    "    # Syncronize threads\n",
    "    stream.synchronize()\n",
    "    \n",
    "    return output"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is all we need to run predictions using our TensorRT engine in a Python runtime!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "id": "AdKZzW7O8qvB"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Warming up...\n",
      "Done warming up!\n"
     ]
    }
   ],
   "source": [
    "print(\"Warming up...\")\n",
    "\n",
    "trt_predictions = predict(input_batch).astype(np.float32)\n",
    "\n",
    "print(\"Done warming up!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Class | Probability (out of 1)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[(160, 0.3112793),\n",
       " (169, 0.27026367),\n",
       " (212, 0.17321777),\n",
       " (170, 0.07165527),\n",
       " (207, 0.033843994)]"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "indices = (-trt_predictions[0]).argsort()[:5]\n",
    "print(\"Class | Probability (out of 1)\")\n",
    "list(zip(indices, trt_predictions[0][indices]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that we have recovered our same predictions as before!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Performance Comparison:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Last, we can see how quickly we can feed a singular batch to TensorRT, which we can compare to our original Tensorflow experiment from earlier."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We use the %%timeit Jupyter magic again. Note that %%timeit is fairly rough, and for any actual benchmarking better controlled testing is required - preferably outside of Jupyter."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "id": "XAtWnCK38qvD"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6.41 ms ± 846 ns per loop (mean ± std. dev. of 7 runs, 100 loops each)\n"
     ]
    }
   ],
   "source": [
    "%%timeit\n",
    "\n",
    "_ = predict(input_batch) # Check TRT performance"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Next Steps:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h4> Profiling </h4>\n",
    "\n",
    "This is a great next step for further optimizing and debugging models you are working on productionizing\n",
    "\n",
    "You can find it here: https://docs.nvidia.com/deeplearning/tensorrt/best-practices/index.html\n",
    "\n",
    "<h4>  TRT Dev Docs </h4>\n",
    "\n",
    "Main documentation page for the ONNX, layer builder, C++, and legacy APIs\n",
    "\n",
    "You can find it here: https://docs.nvidia.com/deeplearning/tensorrt/developer-guide/index.html\n",
    "\n",
    "<h4>  TRT OSS GitHub </h4>\n",
    "\n",
    "Contains OSS TRT components, sample applications, and plugin examples\n",
    "\n",
    "You can find it here: https://github.com/NVIDIA/TensorRT\n",
    "\n",
    "\n",
    "#### TRT Supported Layers:\n",
    "\n",
    "https://github.com/NVIDIA/TensorRT/tree/master/samples/opensource/samplePlugin\n",
    "\n",
    "#### TRT ONNX Plugin Example:\n",
    "\n",
    "https://docs.nvidia.com/deeplearning/tensorrt/support-matrix/index.html#layers-precision-matrix\n"
   ]
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "name": "ONNXExample.ipynb",
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
